home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / boot / netBoot / dev / cg2reg.h < prev    next >
Encoding:
C/C++ Source or Header  |  1988-05-13  |  6.8 KB  |  208 lines
  1.  
  2. /*    @(#)cg2reg.h 1.1 86/09/27 SMI    */
  3.  
  4. /*
  5.  * Copyright (c) 1986 by Sun Microsystems, Inc.
  6.  */
  7.  
  8. /*
  9.  * Description of SUN-2 hardware color frame buffer.
  10.  */
  11.  
  12. /*
  13.  * Structure defining the way in which the address bits to the
  14.  * SUN-2 color frame buffer are decoded.
  15.  */
  16.  
  17. #define CG2_WIDTH    1152
  18. #define CG2_HEIGHT    900
  19. #define CG2_SQUARE    1024
  20. #define CG2_DEPTH    8
  21. #define COLOR_ZOOM_PME_OFF    0
  22. #define COLOR_WPAN_PME_OFF      0x800
  23. #define COLOR_PPAN_PME_OFF      0x800
  24. #define COLOR_VZOOM_PME_OFF     0
  25. #define COLOR_MAPS_PME_OFF     0
  26. #define COLOR_STAT_PME_OFF     0x800
  27. #define COLOR_MASK_PME_OFF    0
  28.  
  29. struct    cg2memfb {
  30.     union bitplane {            /* word mode memory */
  31.         short word[CG2_HEIGHT][CG2_WIDTH/(8*sizeof(short))];
  32.         short sword[CG2_SQUARE][CG2_SQUARE/(8*sizeof(short))];
  33.     } memplane[8];
  34.     union byteplane {            /* pixel mode memory */
  35.         u_char pixel[CG2_HEIGHT][CG2_WIDTH];
  36.         u_char spixel[CG2_SQUARE][CG2_SQUARE];
  37.     } pixplane;
  38. };
  39. struct    cg2statusreg {
  40.     unsigned unused  : 4;    /* reserved for future use */
  41.     unsigned resolution : 4;/* screen resolution */
  42.                 /* 0 = 900 x 1152 */
  43.                 /* 1 = 1024 x 1024 */
  44.     unsigned retrace : 1;    /* rdonly: monitor in retrace */
  45.     unsigned inpend  : 1;    /* rdonly: interrupt pending */
  46.     unsigned ropmode : 3;    /* Rasterop mode */
  47.     unsigned inten   : 1;    /* enab interrupt at end of retrace */
  48.     unsigned update_cmap : 1;
  49.                 /* copy TTL cmap to ECL cmap next vert retrace*/
  50.                 /* silently disables writing to TTL cmap */
  51.     unsigned video_enab  : 1;    /* enab video DACs */
  52. };
  53. struct    cg2fb {
  54.     union {                    /* ROP mode memory */
  55.         union bitplane ropplane[8];    /* word mode memory with ROP */
  56.         union byteplane roppixel;    /* pixel mode memory with ROP */
  57.     } ropio;
  58.     union {                    /* rasterop unit control */
  59.         struct memropc ropregs;        /* normal register access */
  60.         struct {
  61.             char pad[2048];        /* for pixmode src reg prime */
  62.             struct memropc ropregs;    /* byte xfer loads alternate */
  63.         } prime;            /* src register bits */
  64.         char pad[4096];
  65.     } ropcontrol[9];
  66.     union {                /*----- status register */
  67.         struct cg2statusreg reg;
  68.         short word;
  69.         char pad[4096];
  70.     } status;
  71.     union {                /*----- per plane mask register */
  72.         unsigned short reg;        /* 8 bits 1bit -> wr to plane*/
  73.         char pad[4096];
  74.     } ppmask;
  75.     union {                /*----- word pan register */
  76.         unsigned short reg;        /* hi 16 of 20 bit pix addr */
  77.                         /* pix addr = CG2_WIDTH*y+x */
  78.         char pad[4096];
  79.     } wordpan;
  80.     union {                /*----- zoom and line offset register */
  81.         struct {
  82.             unsigned unused  : 8;
  83.             unsigned lineoff : 4;    /* y offset into zoomed pixel */
  84.             unsigned pixzoom : 4;    /* zoomed pixel size - 1 */
  85.         } reg;
  86.         short word;
  87.         char pad[4096];
  88.     } zoom;
  89.     union {                /*----- pixel pan register */
  90.         struct {
  91.             unsigned unused   : 8;
  92.             unsigned lorigin  : 4;    /* lo 4 bits of pix addr   */
  93.             unsigned pixeloff : 4;    /* zoomed pixel x offset/4 */
  94.         } reg;
  95.         short word;
  96.         char pad[4096];
  97.     } pixpan;
  98.     union {                /*----- variable zoom register */
  99.                         /* reset zoom after line no */
  100.         unsigned short reg;        /* line number 0..1024/4  */
  101.         char pad[4096];
  102.     } varzoom;
  103.     union {                /*----- interrupt vector register */
  104.         unsigned short reg;        /* line number 0..1024/4  */
  105.         char pad[4096];
  106.     } intrptvec;
  107.     u_short redmap[256];            /* shadow color maps */
  108.     u_short greenmap[256];
  109.     u_short bluemap[256];
  110. };
  111. /*
  112.  *    ROPMODE            PARALLEL         LD_DST  LD_SRC   Description
  113.  *                           ON      ON        */
  114. #define    PRWWRD    0    /* parallel 8 plane,  read    write,    wrdmode */
  115. #define    SRWPIX    1    /* single     pixel,  read    write,     pixmode */
  116. #define    PWWWRD    2    /* parallel 8 plane,  write   write,    wrdmode */
  117. #define    SWWPIX    3    /* single     pixel,  write   write,    pixmode */
  118. #define    PRRWRD    4    /* parallel 8 plane,  read    read,    wrdmode */
  119. #define    PRWPIX    5    /* parallel16 pixel,  read    write,    pixmode */
  120. #define    PWRWRD    6    /* parallel 8 plane,  write   read,    wrdmode */
  121. #define    PWWPIX    7    /* parallel16 pixel,  write   write,    pixmode */
  122. /*
  123.  * ROP control unit numbers
  124.  */
  125. #define CG2_ROP0    0    /* rasterop unit for bit plane 0 */
  126. #define CG2_ROP1    1    /* rasterop unit for bit plane 1 */
  127. #define CG2_ROP2    2
  128. #define CG2_ROP3    3
  129. #define CG2_ROP4    4
  130. #define CG2_ROP5    5
  131. #define CG2_ROP6    6
  132. #define CG2_ROP7    7
  133. #define CG2_ALLROP    8    /* writes to all units enabled by PPMASK */
  134.                 /* reads from plane zero */
  135.                 
  136. #define    CG_SRC        0xCC
  137. #define    CG_DEST        0xAA
  138. #define    CG_MASK        0xf0
  139. #define    CG_NOTMASK    0x0f
  140. #define    CGOP_NEEDS_MASK(op)        ( (((op)>>4)^(op)) & CG_NOTMASK)
  141.  
  142. /*
  143.  *----------- Defines for accessing the rasterop units
  144.  */
  145. #define    cg2_setrsource(fb, ropunit, val)                \
  146.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_source1 = (val))
  147. #define    cg2_setlsource(fb, ropunit, val)                \
  148.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_source2 = (val))
  149. #define    cg2_setfunction(fb, ropunit, val)                \
  150.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_op = (val))
  151. #define    cg2_setpattern(fb, ropunit, val)                \
  152.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_pattern = (val))
  153. #define    cg2_setshift(fb, ropunit, shft, dir)                \
  154.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_shift =    \
  155.          (shft)|((dir)<<8)    )
  156. #define    cg2_setwidth(fb, ropunit, w, count)                \
  157.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_width = (w));    \
  158.         ((fb)->ropcontrol[(ropunit)].ropregs.mrc_opcount = (count))
  159.  
  160. /*
  161.  *----------- Defines for accessing the zoom and pan registers
  162.  */
  163. #define    cg2_setzoom(fb, pixsize)                    \
  164.         ((fb)->zoom.reg.pixzoom = (pixsize)-1)
  165. #define    cg2_setpanoffset(fb, xoff, yoff)                \
  166.         ((fb)->pixpan.reg.pixeloff = (xoff)>>2;            \
  167.          (fb)->zoom.reg.lineoff = (yoff))
  168. #define    cg2_setpanorigin(fb, x, y)                    \
  169.         ((y) = ((fb)->status.reg.resolution == 1) ?        \
  170.             (y)*CG2_SQUARE+(x) : (y)*CG2_WIDTH+(x);        \
  171.          (fb)->pixpan.reg.lorigin = (y)&0xf;            \
  172.          (fb)->wordpan.reg = (y)>>4)
  173. #define    cg2_setzoomstop(fb, y)                        \
  174.         ((fb)->varzoom.reg = (y)>>2)
  175.  
  176. /*
  177.  *      Defines that facilitate addressing the frame buffer
  178.  */
  179.  
  180. #define    cg2_pixaddr(fb, x, y)                        \
  181.         (((fb)->status.reg.resolution) ?            \
  182.             &(fb)->pixplane.spixel[(y)][(x)] :        \
  183.             &(fb)->pixplane.pixel[(y)][(x)] )
  184. #define    cg2_wordaddr(fb, plane, x, y)                    \
  185.         (((fb)->status.reg.resolution) ?            \
  186.             &(fb)->memplane[(plane)].sword[(y)][(x)>>4] :    \
  187.             &(fb)->memplane[(plane)].word[(y)][(x)>>4])
  188. #define    cg2_roppixaddr(fb, x, y)                    \
  189.         (((fb)->status.reg.resolution) ?            \
  190.             &(fb)->ropio.roppixel.spixel[(y)][(x)] :    \
  191.             &(fb)->ropio.roppixel.pixel[(y)][(x)])
  192. #define    cg2_ropwordaddr(fb, plane, x, y)                \
  193.         (((fb)->status.reg.resolution) ?            \
  194.             &(fb)->ropio.ropplane[(plane)].sword[(y)][(x)>>4]:\
  195.             &(fb)->ropio.ropplane[(plane)].word[(y)][(x)>>4])
  196. #define    cg2_width(fb )                            \
  197.         ( ((fb)->status.reg.resolution)    ? CG2_SQUARE : CG2_WIDTH )
  198. #define    cg2_height(fb )                            \
  199.         ( ((fb)->status.reg.resolution)    ? CG2_SQUARE : CG2_HEIGHT )
  200. #define    cg2_linebytes(fb, mode)                        \
  201.         ( ((fb)->status.reg.resolution)                \
  202.             ? ( ((mode)&1)?CG2_SQUARE:CG2_SQUARE/8 )    \
  203.             : ( ((mode)&1)?CG2_WIDTH:CG2_WIDTH/8   ))
  204. #define    cg2_prskew( x)                            \
  205.          ((x) & 15)
  206.  
  207. #define    cg2_touch(a)    ((a)=0)
  208.